package com.zang.netty.biopool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 时间服务器线程池
 * @author Zhang Qiang
 * @Date 2019/7/18 17:49
 */
public class TimeServerHandlerExecutePool {

     /**
      * 线程池服务接口
      */
    private ExecutorService executorService;

    /**
     *
     * @Param maxPoolSize 最大线程池大小
     * @Param queueSize 队列长度
     *
     */
    public TimeServerHandlerExecutePool(int maxPoolSize, int queueSize){


/**            new ThreadPoolExecutor(
               int corePoolSize,  核心线程池大小// Runtime.getRuntime().availableProcessors(), 返回可用于Java虚拟机的处理器数量
               int maximumPoolSize, 最大线程池大小// maxPoolSize
               long keepAliveTime,  线程最大空闲时间 120L
               TimeUnit unit, 时间单位 TimeUnit.SECONDS 秒
               BlockingQueue<Runnable> workQueue) { 线程等待队列// ArrayBlockingQueue队列，先进先出。 queueSize 队列长度
                   this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                        Executors.defaultThreadFactory(), defaultHandler);
               }
 */
        executorService = new ThreadPoolExecutor(
                Runtime.getRuntime().availableProcessors(),
                maxPoolSize,
                120L,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(queueSize));

    }
     /**
      * 通过ExecutorService执行Runnable
      */
    public void execute(Runnable task){
         /**
          * execute(Runnable command);继承字Executor， 在将来的某个时间执行给定的命令。
          */
        executorService.execute(task);
    }


}
